import java.util.*;
import com.sun.xml.internal.ws.message.stream.StreamAttachment;
//--------------------------------------------------------------------
//laboratorio No. 6
//Yucely Beb 12537
//Victor Fuentes 12298
//Roger Diaz 12176
//------------------------------------------------------------------
//Este programa el usuario  tiene a seleccionar la 
//implementación de SET que usará su programa, en tiempo de corrida. El 
//usuario debe seleccionar entre: 1)HashSet, 2)TreeSet, 3)LinkedHashSet
//-------------------------------------------------------------------
public class NewMain {      //

    //atributos
    public int intLista;
    public String strMensaje;
    
  
    public static void main(String[] args) {
        // TODO code application logic here
        //usando factory se puede utilizar alguno de los 3 tipos segun la eleccion
        
        //variables
        int ingreso=0;  //elecciones para las diferentes implementaciones
        boolean error=true; //variable para errores en ingreso, es true para que pueda ingresar a ciclos while
        int eleccion=0;     //variable para las elecciones de  ingreso de los nombres en las listas
        System.out.println("-------------Bienvenido a la Hoja de Trabajo No. 6-------------------");
        
        FactoryConjuntos _Factory = new    FactoryConjuntos();
        System.out.println("Ingrese su opción de implementación para Java:");
        System.out.println("1. HashSet");
        System.out.println("2. TreeSet");
        System.out.println("3. HashLinkedList");
        //se toma resultado de eleccion
        Scanner  _lector = new Scanner(System.in);

        //programación defensiva 
        try{
            ingreso=_lector.nextInt();
            if(ingreso>3){
                System.out.println("Ingreso erroneo, se usara HastSet por defecto");
                ingreso=1;
            }
        }catch(Exception e){
             System.out.println("Ingreso erroneo, se usara HastSet por defecto");
            ingreso=1;
            _lector.next();     //instruccion para limpiar el buffer del scanner
        }
        
        Set<String> _Java = _Factory.ObtenerSet(ingreso);
        
       
        
        //se selecciona cual seria la implementacion segun el tipo de programacion
        
        //se selecciona alguna de las 3 implementaciones para programacion web
        System.out.println("Ingrese su opción para implementación para Web");
        System.out.println("1. HastSet");
        System.out.println("2. TreeSet");
        System.out.println("3. LinkedHashSet");
        
        //si hay error, se usara hastset por defecto
        
        try{
            ingreso=_lector.nextInt();
            if(ingreso>3){
                System.out.println("Ingreso erroneo, se usara HastSet por defecto");
                ingreso=1;
            }
            
        }catch(Exception e){
             System.out.println("Ingreso erroneo, se usara HastSet por defecto");
            ingreso=1;
             _lector.next();     //instruccion para limpiar el buffer del scanner
        }
        
        Set<String> _Web = _Factory.ObtenerSet(ingreso);
       
       
        

        //se selecciona alguna de las 3 implementaciones para programacion cel
        System.out.println("Ingrese su opción para implementación para Cel");
        System.out.println("1. HashSet");
        System.out.println("2. TreeSet");
        System.out.println("3. HashLinkedList");
        try{
            ingreso=_lector.nextInt();
            if(ingreso>3){
                System.out.println("Ingreso erroneo, se usara HastSet por defecto");
                ingreso=1;
            }
        }catch(Exception e){
             System.out.println("Ingreso erroneo, se usara HastSet por defecto");
            ingreso=1;
             _lector.next();     //instruccion para limpiar el buffer del scanner
        }
        
        
        Set<String> _Cel = _Factory.ObtenerSet(ingreso);
        
        System.out.println("\n------------------------------------------------------");
        //se debe de ver cuantas personas se van a agregar a los 3 tipos de programacion
        
        //int contador=0;
        int cont=0;
        while(error){               //ciclo para forzar a aceptar un valor valido para la cantidad de personas que se agrega a las listas
            try{
                System.out.println("Ingrese numero de personas a agregar a los conjuntos:");
                cont=_lector.nextInt();
                
                //se setea error como false para que ya no siga con el ingreso de la cantidad de personas
                error=false;

            }catch(Exception a){
                System.out.println("Ingreso erroneo, ");
                //seguira true hasta que se ingrese bien lo que se pide
                error=true;
                _lector.next();     //instruccion para limpiar el buffer del scanner
            } 
        }
        
        
        //al tomar la canidad se debe de ver que sea la misma que el programa deja ingresar
        while(cont>0){
            System.out.println("Ingrese nombre:");
            //se toma el nombre ingresado
            String nombre=_lector.next();
            //se manda cero o uno para ingresar el nombre segun los tipos de programacion que este sabe realizar
            System.out.println("Ingrese 1 para SI, ingrese cualquier otro caracter para NO");
            
            //ingresar 1 o 0 para que el nombre este en programacion web
            System.out.println("\nIngresar en Web:");
            
            try{
                eleccion=_lector.nextInt();
                //si se decide que si se quiere ingresar el nombre se usa 1
                if(eleccion==1){
                    System.out.println("Si se ingreso:"+nombre+ " a la lista Web");
                    //se agrega con add
                   _Web.add(nombre); 
                   //si es cero no se ingresa
                }else  System.out.println("No se ingreso:"+nombre+ " a la lista Web");
                //si se pone otra cosa que no sea 1 o cero se manda a la progra defensiva que no lo ingresa
            }catch(Exception f){
                System.out.println("No se ingreso:"+nombre+ " a la lista Web");
                _lector.next();     //linea de codigo para limpiar el buffer del scanner
            }

            //ingresar 1 o 0 para que el nombre este en programacion java
            System.out.println("\nIngresar en Java:");
            
            //este es el mismo proceso que el de web y el de celular pero se agrega a la lista de Java
            try{
                eleccion=_lector.nextInt();
                if(eleccion==1){
                    System.out.println("Si se ingreso:"+nombre+ " a la lista Java");
                    //se agrega con add si es correcto 
                   _Java.add(nombre); 
                   //si es cero no se ingresa
                }else System.out.println("No se ingreso:"+nombre+ " a la lista Java");
            }catch(Exception f){
                //si se pone otra cosa que no sea 1 o cero se manda a la progra defensiva que no lo ingresa
                System.out.println("No se ingreso:"+nombre+ " a la lista Java");
                _lector.next();     //linea de codigo para limpiar el buffer del scanner
            }
         
            
            //ingresar 1 o 0 para que el nombre este en programacion de celulares
            System.out.println("\nIngresar en Cel:");
            //este es el mismo proceso que java y web pero se ingresa a la lista de celular
            try{
                eleccion=_lector.nextInt();
                if(eleccion==1){
                    System.out.println("Si se ingreso:"+nombre+ " a la lista Celulares");
                   _Cel.add(nombre); 
                   //se agrega con add si es correcto 
                }else System.out.println("No se ingreso:"+nombre+ " a la lista Celulares");
                 //si es cero no se ingresa
            }catch(Exception f){
                //si se pone otra cosa que no sea 1 o cero se manda a la progra defensiva que no lo ingresa
                System.out.println("No se ingreso:"+nombre+ " a la lista Celulares");
                _lector.next();     //linea de codigo para limpiar el buffer del scanner
            }
            
            
            
            System.out.println("\n------------------------------------------------------");
            //a la variable usada en while se le va restando para que asi se trabaje la cantidad que 
            //se ingresa
            cont--;
        }
        
        
        //gracias a Iterator se puede ver el contenido completo de cada lista para poderla imprimir
        Iterator _iter=_Web.iterator();
        System.out.println("Lista de Desarrolladores Web");
        
        //siempre que haya algun elemento en la lista se va a imprimir
        while(_iter.hasNext()){
            System.out.println(_iter.next());
        }
        
        //impresion si esta vacio
        if(_Web.isEmpty()){
            System.out.println("Lista de Desarrolladores Web esta vacia");
        }
        System.out.println("\n------------------------------------------------------");
        
        
        //para imprimir lo que haya en Java
        System.out.println("Lista de Desarrolladores Java");
        _iter=_Java.iterator();
        //siempre que haya algun elemento en la lista se va a imprimir
        while(_iter.hasNext()){
            System.out.println(_iter.next());
        }
        
        //impresion si esta vacio
        if(_Java.isEmpty()){
            System.out.println("Lista de Desarrolladores Java esta vacia");
        }
        System.out.println("\n------------------------------------------------------");
        
        //para imprimir lo que haya en celulares
        System.out.println("Lista de Desarrolladores Celulares");
        _iter=_Cel.iterator();
        //siempre que haya algun elemento en la lista se va a imprimir
        while(_iter.hasNext()){
            System.out.println(_iter.next());
        }
        
        //impresion si esta vacio
        if(_Cel.isEmpty()){
            System.out.println("Lista de Desarrolladores Celulares esta vacia");
        }
        
        System.out.println("\n------------------------------------------------------");
        
        
        //1. DESARROLLADORES CON EXPERIENCIA JAVA, WEB Y CELULARES (interseccion de los tres) 
        System.out.println("1. Lista de intersección entre desarrolladores Java, Web y Celular:");
        
        //definir lista resultado
        Set<String> _Resultado = new HashSet<String>();
        _Resultado.addAll(_Web);
        _Resultado.addAll(_Java);
        _Resultado.addAll(_Cel);
        
        //cada una de las listas va a mantener solo lo que si contenga
        //al final esto va a ser como una interseccion
        _Resultado.retainAll(_Cel);
        _Resultado.retainAll(_Web);
        _Resultado.retainAll(_Java);
        
        
        //con iterator se obtiene el acceso a la lista de resultado
        _iter=_Resultado.iterator();
        
        //mientras haya algo en esa lista se debe imprimir
        while(_iter.hasNext()){
            System.out.println(_iter.next());
        }
        
        //impresion si esta vacio
        if(_Resultado.isEmpty()){
            System.out.println("No hay interseccion entre Java, Celulares y Web");
        }
        System.out.println("\n------------------------------------------------------");
        
        
        
        
        //2. DESARROLLADORES CON EXPERIENCIA EN JAVA, PERO NO EN WEB
        //impresion de lista con java que no tengan experiencia en web
        
        System.out.println("2. Lista de Desarrolladores Java sin experiencia Web");
        //se define la lista de resultado con la que se va a trabajar para dar la lista de personas con experiencia en java y no en web
        Set<String> _Resultado1 = new HashSet<String>();
        
        _Resultado.clear(); //limpieza de _Resultado para usar despues
        
        //se mete la lista de programadores de java
        _Resultado.addAll(_Java);
        _Resultado.retainAll(_Web);     //interseccion entre java y WEb
        
        _Resultado1.addAll(_Java);//se vuelve a ingresar los programadores de java
        _Resultado1.removeAll(_Resultado); //quito interseccion en _Resultado a Resultado1
                                            //tengo java, sin web
        
        //con iterator se obtiene acceso a Resultado1 y se controla para imprimir
        _iter=_Resultado1.iterator();
        while(_iter.hasNext()){
            System.out.println(_iter.next());
        }
        
        //impresion si esta vacio
        if(_Resultado1.isEmpty()){
            System.out.println("No hay desarrolladores Java sin experiencia Web");
        }
        System.out.println("\n------------------------------------------------------");
        
        
        
        
        //3. DESARROLLADORES CON EXPERIENCIA WEB y CELULARES, PERO NO JAVA
        //desarrollaodres web y cel, pero que no tengan experiencia en java
        System.out.println("3. Lista con desarrollaodres Web y Cel pero sin experiencia en Java");
        
        //se limpian las listas que se usaron para volver a trabajar con esas
        _Resultado.clear();
        _Resultado1.clear();    //limpieza de listas
                
        //se agrega la lista de web y celular
        _Resultado.addAll(_Web);
        _Resultado.addAll(_Cel);
        
        //se hace la interseccion de estas listas con java
        _Resultado.retainAll(_Java);    //con la union de web y cel, obtengo la interseccion con java
        
        //se agrega la lista de web
        _Resultado1.addAll(_Web);
        _Resultado1.retainAll(_Cel);       //interseccion de web y cel
        _Resultado1.removeAll(_Resultado);  //resto interseccion de web y cel, e interseccion de este conjunto con java
                
        
        //con iterator se saca el resultado
         _iter=_Resultado1.iterator();
        while(_iter.hasNext()){
            System.out.println(_iter.next());
        }
        
        //impresion si esta vacio
        if(_Resultado1.isEmpty()){
            System.out.println("No hay desarrolladores Web y celulares sin experiencia en Java");
        }
        System.out.println("\n------------------------------------------------------");
        
        
        
        //4. DESARROLLADORES CON EXPERIENCIA WEB 0 CELULARES, PERO NO JAVA
        System.out.println("4. Impresion de Desarrolladores Web o Celulares, pero no en java");
        
        //limpieza de listas resultado y resultado1
        _Resultado1.clear(); _Resultado.clear();
        
        //union de web y cel
        _Resultado.addAll(_Web);
        _Resultado.addAll(_Cel);
        
        //interseccion de todos
        _Resultado1.addAll(_Web);
        _Resultado1.addAll(_Cel);
        
        _Resultado1.retainAll(_Java);    //con la union de web y cel, obtengo la interseccion con java
        
        //con union en resultado, le quito la interseccionen resultado1
        _Resultado.removeAll(_Resultado1);
        _iter=_Resultado.iterator();
        while(_iter.hasNext()){
            System.out.println(_iter.next());
        }
        
        //impresion si esta vacio
        if(_Resultado.isEmpty()){
            System.out.println("No hay desarrolladores Web o Celular, sin experiencia en Java");
        }
        System.out.println("\n------------------------------------------------------");
        
        
        
        System.out.println("5. Indicacion de si el conjunto Java es subconjunto de Web ");
        //5. INDICAR SI O NO EL CONJUNTO DE DESARROLLADORES JAVA ES SUBCONJUNTO
        //DE DESARROLLADORES WEB
        //limpieza de resultado y resultado1
        _Resultado1.clear();
        _Resultado.clear();
        
        _Resultado.addAll(_Web); //obtener todo el conjunto Web
        _Resultado1.addAll(_Java); //obtener todo el conunto java
                                               //o sea si Resultado1 es subconjunto de resultado
        if(!_Resultado1.isEmpty() ){             //validar que no este vacio
            if(_Resultado.containsAll(_Resultado1)){
                //Se imprime el resultado 
                System.out.println("Desarrolladores Java Si es subconjunto de Desarrolladores Web");
                
                
            }else System.out.println("Desarrolladores Java No es subconjunto de Desarrolladores Web");
            
        }else System.out.println("Desarrolladores Java esta vacio");
        
        
        
         System.out.println("\n------------------------------------------------------");
        
        
        
        System.out.println("6. Conjunto (Java, web o celulares) que tenga la cantidad mas grande de desarrolladores, y los nombres de esos desarrolladores ");
         //limpieza de resultado y resultado1
        _Resultado1.clear();_Resultado.clear();
        _Resultado.addAll(_Web); //obtener todo el conjunto Web
        //Se toma el tama;o de lista Web
        int paraWeb=_Resultado.size();
        _Resultado.clear();
        
        _Resultado.addAll(_Java); //obtener todo el conunto java
        //Se toma el tama;o de lista Java
        int paraJava=_Resultado.size();
        _Resultado.clear();
        
        _Resultado.addAll(_Cel); //obtener todo el conunto celulares 
        //Se toma el tama;o de lista Cel
        int paraCel=_Resultado.size();
        _Resultado.clear();
        
        //si web es mayor que java y cel
        if(paraWeb > paraJava || paraWeb > paraCel){
        System.out.println("La Lista con mayor cantidad de programadores es de Web");
        _Resultado.addAll(_Web); //obtener todo el conjunto Web
        _iter=_Resultado.iterator();
        while(_iter.hasNext()){
            System.out.println(_iter.next()); //se imprimer la lista
        }        
        }
        
        //si java es mayor que web y cel
        if(paraJava > paraWeb || paraJava > paraCel){
        System.out.println("La Lista con mayor cantidad de programadores es de Java");
        _Resultado.addAll(_Java); //obtener todo el conjunto Web   
        _iter=_Resultado.iterator();
        while(_iter.hasNext()){
            System.out.println(_iter.next());//se imprime la lista
        }
        }
        
        //si cel es mayor que java y web
        if(paraCel > paraJava || paraCel > paraWeb){
        System.out.println("La Lista con mayor cantidad de programadores es de Celulares");
        _Resultado.addAll(_Cel); //obtener todo el conjunto Web 
         _iter=_Resultado.iterator();
        while(_iter.hasNext()){
            System.out.println(_iter.next());//se imprime la lista
        }      
        }     
        
         System.out.println("\n------------------------------------------------------");
        
        
         
         
         
         //si se escriben algunos nombres en mayuscula y otros en minuscula, va a tomar primero para imprimir en ascendente los de mayuscula y luego en 
         //ascendente los de minuscula
        System.out.println("7. Conjunto (Java, web o celulares) que tenga la cantidad mas grande de desarrolladores, y los nombres de esos desarrolladores en orden ascendente");
        //limpieza de resultado y resultado1
        _Resultado1.clear();
        _Resultado.clear();
        _Resultado.addAll(_Web); //obtener todo el conjunto Web
        //Se toma el tama;o de lista Web
        int ParaWeb=_Resultado.size();
        _Resultado.clear();
        
        _Resultado.addAll(_Java); //obtener todo el conunto java
        //Se toma el tama;o de lista Java
        int ParaJava=_Resultado.size();
        _Resultado.clear();
        
        _Resultado.addAll(_Cel); //obtener todo el conunto celulares 
        //Se toma el tama;o de lista Cel
        int ParaCel=_Resultado.size();
        _Resultado.clear();
        
        
        try{
        //si web es mayor que java y cel
        if(ParaWeb > ParaJava || ParaWeb > ParaCel){
        System.out.println("La Lista con mayor cantidad de programadores es de Web");
        _Resultado.addAll(_Web); //obtener todo el conjunto Web
        
        //se pasa a un array, asi se puede ordenar
        String[] deWeb=_Resultado.toArray(new String[0]);
        
        //se ordena con sort
        Arrays.sort(deWeb);
        //ciclo para imprimir todo
        for(int i = 0; i<ParaWeb; i++){
            System.out.println(deWeb[i]);
        }       
        }
        
        //si java es mayor que web y cel
        if(ParaJava > ParaWeb || ParaJava > ParaCel){
        System.out.println("La Lista con mayor cantidad de programadores es de Java");
        _Resultado.addAll(_Java); //obtener todo el conjunto Web
        
        //se crea array para poner la lista java
        String[] deJava=_Resultado.toArray(new String[0]);
        
        //se ordena
        Arrays.sort(deJava);
        
        //ciclo de impresion
        for(int i = 0; i<ParaWeb; i++){
            System.out.println(deJava[i]);
        }
        }
        
        //si cel es mayor que java y web
        if(ParaCel > ParaJava || ParaCel > ParaWeb){
        System.out.println("La Lista con mayor cantidad de programadores es de Celulares");
        _Resultado.addAll(_Cel); //obtener todo el conjunto Web 
        
        //se crea el array para poder guardar la lista
        String[] deCel=_Resultado.toArray(new String[0]);
        
        //ordena la lista
        Arrays.sort(deCel);
        //ciclo de impresion
        for(int i = 0; i<ParaWeb; i++){
            System.out.println(deCel[i]);
        }      
        }           
        }
        //programación defensiva
        catch(Exception e){
        
        }
       System.out.println("\n------------------------------------------------------");
         
    }
}